{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法\n",
    "\n",
    "DQN 经验回放的算法中的均匀采样算法，可能会忘记一些重要的、以后使用的经验数据。针对这样的问题，PER_DQN 提出了优先级经验回放（prioritized experience reolay）的技术来解决，这种方法应用到 DQN 获得了更好的效果。PER_DQN 成功的原因有：\n",
    "1. 提出了sum tree这样复杂度为O(logn)的高效数据结构\n",
    "2. 正确估计了 weighted importance sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, n_states,n_actions,hidden_dim=128):\n",
    "        \"\"\" 初始化q网络，为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.fc1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.fc2 = nn.Linear(hidden_dim,hidden_dim) # 隐藏层\n",
    "        self.fc3 = nn.Linear(hidden_dim, n_actions) # 输出层\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        x = F.relu(self.fc1(x)) \n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc3(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "在实现上PER有两种方式，一个是简版PER，另一个就是接近原论文的SumTree PER，两者主要有以下不同：\n",
    "\n",
    "* 数据结构: 前者使用数组保存优先级，后者则用二叉树(SumTree)保存\n",
    "* 采样复杂度: 采样时前者是直接用概率分布随机，复杂度是 O(N)（慢）, 后者用树查找，复杂度是 O(log N)（快）\n",
    "* 更新优先级复杂度: 前者直接更新数组，O(1)（快）, 后者更新树上的节点，O(log N)（稍慢，但可以承受）\n",
    "* 内存开销: 小（1个数组）, 后者略大（1棵树 + 1个数据数组）\n",
    "* 适合场景： 小 buffer（比如几千条数据以内）, 大 buffer（比如一万到几十万条数据）\n",
    "\n",
    "这里默认使用SumTree PER, 想看简版实现以便于理解概念的同学可参考带\"SimpleBuffer\"字样的notebook\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class SumTree:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        self.data = np.zeros(capacity, dtype=object)\n",
    "        self.data_pointer = 0\n",
    "\n",
    "    def add(self, priority, data):\n",
    "        tree_idx = self.data_pointer + self.capacity - 1\n",
    "        self.data[self.data_pointer] = data\n",
    "        self.update(tree_idx, priority)\n",
    "        self.data_pointer += 1\n",
    "        if self.data_pointer >= self.capacity:\n",
    "            self.data_pointer = 0\n",
    "\n",
    "    def update(self, tree_idx, priority):\n",
    "        change = priority - self.tree[tree_idx]\n",
    "        self.tree[tree_idx] = priority\n",
    "        while tree_idx != 0:\n",
    "            tree_idx = (tree_idx - 1) // 2\n",
    "            self.tree[tree_idx] += change\n",
    "\n",
    "    def get_leaf(self, v):\n",
    "        parent_idx = 0\n",
    "        while True:\n",
    "            left_child_idx = 2 * parent_idx + 1\n",
    "            right_child_idx = left_child_idx + 1\n",
    "            if left_child_idx >= len(self.tree):\n",
    "                leaf_idx = parent_idx\n",
    "                break\n",
    "            else:\n",
    "                if v <= self.tree[left_child_idx]:\n",
    "                    parent_idx = left_child_idx\n",
    "                else:\n",
    "                    v -= self.tree[left_child_idx]\n",
    "                    parent_idx = right_child_idx\n",
    "        data_idx = leaf_idx - self.capacity + 1\n",
    "        return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n",
    "    \n",
    "    @property\n",
    "    def max_priority(self):\n",
    "        return self.tree[-self.capacity:].max()\n",
    "        \n",
    "    @property\n",
    "    def total_priority(self):\n",
    "        return self.tree[0]\n",
    "\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, cfg):\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.alpha = cfg.per_alpha\n",
    "        self.beta = cfg.per_beta\n",
    "        self.beta_increment_per_sampling = cfg.per_beta_increment_per_sampling\n",
    "        self.epsilon = cfg.per_epsilon\n",
    "        self.tree = SumTree(self.capacity)\n",
    "        \n",
    "    def push(self, transition):\n",
    "        # max_prio = self.tree.tree[-self.tree.capacity:].max()\n",
    "        max_prio = self.tree.max_priority\n",
    "        if max_prio == 0:\n",
    "            max_prio = 1.0\n",
    "        self.tree.add(max_prio, transition)\n",
    "\n",
    "    def sample(self, batch_size):\n",
    "        self.beta = min(1.0, self.beta + self.beta_increment_per_sampling)\n",
    "        minibatch = []\n",
    "        idxs = []\n",
    "        segment = self.tree.total_priority / batch_size\n",
    "        priorities = []\n",
    "\n",
    "        for i in range(batch_size):\n",
    "            a = segment * i\n",
    "            b = segment * (i + 1)\n",
    "            s = np.random.uniform(a, b)\n",
    "            idx, p, data = self.tree.get_leaf(s)\n",
    "            minibatch.append(data)\n",
    "            idxs.append(idx)\n",
    "            priorities.append(p)\n",
    "\n",
    "        sampling_probabilities = priorities / self.tree.total_priority\n",
    "        is_weight = np.power(self.tree.capacity * sampling_probabilities, -self.beta)\n",
    "        is_weight /= is_weight.max()\n",
    "\n",
    "        batch = list(zip(*minibatch))\n",
    "        return tuple(map(lambda x: np.array(x), batch)), idxs, is_weight\n",
    "\n",
    "    def update_priorities(self, idxs, priorities):\n",
    "        for idx, priority in zip(idxs, priorities):\n",
    "            self.tree.update(idx, (np.abs(priority) + self.epsilon) ** self.alpha)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.tree.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "同 DQN 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg):\n",
    "        self.action_dim = cfg.action_dim  # 动作空间的维度\n",
    "        self.device = torch.device(cfg.device) # CPU或GPU \n",
    "        self.gamma = cfg.gamma  # 奖励的折扣因子\n",
    "        ## e-greedy策略相关参数\n",
    "        self.sample_count = 0  # 用于epsilon的衰减计数\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.batch_size = cfg.batch_size\n",
    "        self.target_update = cfg.target_update\n",
    "        # 当前网络和目标网络\n",
    "        self.model = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        self.target_model = Model(cfg.state_dim, cfg.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # # 复制参数到目标网络\n",
    "        # for target_param, param in zip(self.target_model.parameters(),self.model.parameters()): \n",
    "        #     target_param.data.copy_(param.data)\n",
    "        self.target_model.load_state_dict(self.model.state_dict()) # 复制参数到目标网络\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr) \n",
    "        self.memory = ReplayBuffer(cfg) # 经验回放\n",
    "        self.update_cnt = 0\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' sample action with e-greedy policy\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        # epsilon 指数衰减\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.sample_count / self.epsilon_decay) \n",
    "        if random.random() > self.epsilon:\n",
    "            action = self.predict_action(state) # 预测动作\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim) # 随机动作, 便于前期探索\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0) # [1, state_dim]\n",
    "        q_values = self.model(state)\n",
    "        action = q_values.max(1)[1].item() \n",
    "        return action\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        ''' 获取当前策略的参数\n",
    "        '''\n",
    "        return self.model.state_dict()\n",
    "    \n",
    "    def load_policy_params(self, params):\n",
    "        ''' 加载策略参数\n",
    "        '''\n",
    "        self.model.load_state_dict(params)\n",
    "    \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 采样一个batch\n",
    "        (states, actions, rewards, next_states, dones), idxs, weights = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        states = torch.tensor(np.array(states), device=self.device, dtype=torch.float) # [B, state_dim]]\n",
    "        actions = torch.tensor(actions, device=self.device, dtype=torch.int64).unsqueeze(1) # [B,1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1) # [B,1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [B, state_dim]]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1) # [B,1]\n",
    "        weights = torch.tensor(weights, device=self.device, dtype=torch.float).unsqueeze(1) # [B,1]\n",
    "\n",
    "        q_value = self.model(states).gather(dim=1, index=actions) # [B,1]\n",
    "        next_q_value_max = self.target_model(next_states).max(1)[0].detach().unsqueeze(1) \n",
    "        expected_q_value = rewards + self.gamma * next_q_value_max* (1-dones)\n",
    "        td_errors = abs(q_value - expected_q_value)\n",
    "\n",
    "        # loss中根据优先度进行了加权\n",
    "        loss = (td_errors ** 2 * weights).mean()\n",
    "\n",
    "        priorities = td_errors.squeeze().cpu().detach().numpy() + 1e-5 # 计算TD误差\n",
    "        # 需要更新样本的优先度\n",
    "        self.memory.update_priorities(idxs, priorities) \n",
    "\n",
    "        # 反向传播\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # 梯度截断，防止梯度爆炸\n",
    "        for param in self.model.parameters():  \n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        if self.update_cnt % self.target_update == 0: # 更新 target_model\n",
    "            self.target_model.load_state_dict(self.model.state_dict()) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置参数和定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线, 类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(cfg, frames, rewards):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label='rewards')\n",
    "    plt.plot(frames, smooth(rewards), label='smoothed rewards')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'PER_DQN' # 算法名称\n",
    "        self.env_id = 'Acrobot-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.max_epsiode = 200 # 训练的回合数\n",
    "        self.max_epsiode_test = 20 # 测试的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 2000 # e-greedy策略中epsilon的衰减率\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 64 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        #region buffer相关参数\n",
    "        self.buffer_size = 100000 # 经验回放池的容量\n",
    "        self.per_alpha = 0.6 # 优先级的指数 \n",
    "        self.per_epsilon = 1e-5 # 优先级的最小值\n",
    "        self.per_beta = 0.4 # beta的初始值\n",
    "        self.per_beta_increment_per_sampling = 0.0001 # beta的增量\n",
    "        #endregion\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda'\n",
    "        self.reward_threshold = -80 # 奖励阈值，达到该值则认为训练成功\n",
    "        self.reward_threshold_limit = 10 # 累计一定训练成功次数后停止训练, 这样可以避免训练过长时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "def make_env(cfg: Config):\n",
    "    ''' 创建环境\n",
    "    '''\n",
    "    env = gym.make(cfg.env_id) # 创建环境\n",
    "    setattr(cfg, \"action_space\", env.action_space) # 动作空间\n",
    "    setattr(cfg, \"state_dim\", env.observation_space.shape[0]) # 状态维度\n",
    "    setattr(cfg, \"action_dim\", env.action_space.n) # 动作维度\n",
    "    return env\n",
    "\n",
    "def train(cfg: Config, env, policy):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    reward_threshold_cnt = 0 # 奖励阈值计数器\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, float(truncated or terminated)))   # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            policy.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                if ep_reward >= best_ep_reward:  # 更新最佳策略\n",
    "                    best_ep_reward = ep_reward\n",
    "                    best_policy_params = policy.model.state_dict()\n",
    "                    print(f\"更新最佳策略，回合：{i_ep+1}/{cfg.max_epsiode}, 最佳奖励：{best_ep_reward:.2f}\")\n",
    "                if ep_reward >= cfg.reward_threshold:\n",
    "                    reward_threshold_cnt += 1\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        if reward_threshold_cnt >= cfg.reward_threshold_limit:\n",
    "            print(f\"达到奖励阈值累计{cfg.reward_threshold_limit}次, 训练成功，回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}\")\n",
    "            break\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}, Epislon: {policy.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames, 'best_policy_params':best_policy_params} # 返回训练结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t      PER_DQN       \t   <class 'str'>    \n",
      "       env_id       \t     Acrobot-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "    max_epsiode     \t        200         \t   <class 'int'>    \n",
      "  max_epsiode_test  \t         20         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t        2000        \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t         64         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     per_alpha      \t        0.6         \t  <class 'float'>   \n",
      "    per_epsilon     \t       1e-05        \t  <class 'float'>   \n",
      "      per_beta      \t        0.4         \t  <class 'float'>   \n",
      "per_beta_increment_per_sampling\t       0.0001       \t  <class 'float'>   \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "  reward_threshold  \t        200         \t   <class 'int'>    \n",
      "reward_threshold_limit\t         10         \t   <class 'int'>    \n",
      "     state_dim      \t         6          \t   <class 'int'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：-200.00, Epislon: 0.356\n",
      "回合：20/200，奖励：-200.00, Epislon: 0.137\n",
      "回合：30/200，奖励：-200.00, Epislon: 0.057\n",
      "更新最佳策略，回合：36/200, 最佳奖励：-170.00\n",
      "更新最佳策略，回合：37/200, 最佳奖励：-156.00\n",
      "更新最佳策略，回合：38/200, 最佳奖励：-133.00\n",
      "回合：40/200，奖励：-150.00, Epislon: 0.029\n",
      "更新最佳策略，回合：42/200, 最佳奖励：-88.00\n",
      "更新最佳策略，回合：48/200, 最佳奖励：-84.00\n",
      "回合：50/200，奖励：-86.00, Epislon: 0.021\n",
      "更新最佳策略，回合：58/200, 最佳奖励：-77.00\n",
      "回合：60/200，奖励：-78.00, Epislon: 0.016\n",
      "回合：70/200，奖励：-86.00, Epislon: 0.014\n",
      "更新最佳策略，回合：74/200, 最佳奖励：-64.00\n",
      "回合：80/200，奖励：-77.00, Epislon: 0.012\n",
      "回合：90/200，奖励：-95.00, Epislon: 0.012\n",
      "回合：100/200，奖励：-70.00, Epislon: 0.011\n",
      "回合：110/200，奖励：-71.00, Epislon: 0.011\n",
      "回合：120/200，奖励：-89.00, Epislon: 0.010\n",
      "回合：130/200，奖励：-77.00, Epislon: 0.010\n",
      "回合：140/200，奖励：-80.00, Epislon: 0.010\n",
      "回合：150/200，奖励：-88.00, Epislon: 0.010\n",
      "回合：160/200，奖励：-86.00, Epislon: 0.010\n",
      "更新最佳策略，回合：161/200, 最佳奖励：-61.00\n",
      "更新最佳策略，回合：162/200, 最佳奖励：-60.00\n",
      "回合：170/200，奖励：-101.00, Epislon: 0.010\n",
      "回合：180/200，奖励：-84.00, Epislon: 0.010\n",
      "回合：190/200，奖励：-69.00, Epislon: 0.010\n",
      "回合：200/200，奖励：-77.00, Epislon: 0.010\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "env = make_env(cfg) # 创建环境\n",
    "policy = Policy(cfg)\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg,env,policy) # 训练\n",
    "plot_rewards(cfg, res['frames'], res['rewards'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 策略测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：1/20，奖励：-77.00\n",
      "回合：2/20，奖励：-77.00\n",
      "回合：3/20，奖励：-77.00\n",
      "回合：4/20，奖励：-77.00\n",
      "回合：5/20，奖励：-77.00\n",
      "回合：6/20，奖励：-77.00\n",
      "回合：7/20，奖励：-77.00\n",
      "回合：8/20，奖励：-77.00\n",
      "回合：9/20，奖励：-77.00\n",
      "回合：10/20，奖励：-77.00\n",
      "回合：11/20，奖励：-77.00\n",
      "回合：12/20，奖励：-77.00\n",
      "回合：13/20，奖励：-77.00\n",
      "回合：14/20，奖励：-77.00\n",
      "回合：15/20，奖励：-77.00\n",
      "回合：16/20，奖励：-77.00\n",
      "回合：17/20，奖励：-77.00\n",
      "回合：18/20，奖励：-77.00\n",
      "回合：19/20，奖励：-77.00\n",
      "回合：20/20，奖励：-77.00\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAisAAAHJCAYAAABEynk8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABPeklEQVR4nO3dCbxN9f7/8c8ZHPNwKENSMkSEyBwapCLFLXXTKCJJgwpJmpCkAaUMDYgmrtKV1FX3NrgU1aWIUBkyZ8rMOfv/eH/91/nts+1znMPeWWfv1/Px2I6999prr+8a3+v7/a61EwKBQMAAAAB8KvFETwAAAEB2CCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsxLFr3++M+ggBiEfs2/yKsxKhPP/3U+vbtG/Hxfvvtt9atW7eM52vXrrVq1arZtGnTIv5diA3z5s2zSy+91M4++2y77bbbwg5z0003ufUo+KHhL7jgAnv88cdtx44dGcO+8MILRwwb+ti/f3+2w55zzjlump5//nk7dOhQrsqjdT10fLVq1bKLLrrIBgwYYBs2bAj7uT/++MN93+WXX+6+v0mTJnbLLbfYzJkzs/yOQYMGhR2XV67saDpuuOEGN236rr1791o0vPvuu25aunfvbn81bz5pP+TXfeZTTz3l1m8cn+Tj/Dx8avz48VEZ75QpU2zlypUZz0uXLm3vvPOOnXbaaVH5PuR9Tz/9tKWnp9vYsWOtVKlSWQ5Xo0YNe/TRRzOeHzx40BYvXmzPPfec/fTTT/bWW29ZQkJCxvta77KSkpKS6XnosNu2bbMZM2bY6NGjXVjp3bt3rsv14osv2sknn+z+ryCwfPlyV8bZs2cfsU0sWbLEbr/9dktKSnIBRWX9888/3QHy/vvvt48//tieeeYZy5cvX6bvmDx5sl122WVWv379XE/fhAkT7H//+58NGzbMypQpYwULFrRo+Mc//mFnnnmmffHFF7Z+/XorV66c5UXR2Ge+9tpr9vrrr1vDhg0jPu54Q1jBcdFBQWeJQFa2b99uDRo0sKZNm2Y7XJEiRY5Yl/S53bt328iRI23hwoWZ3s/Nehdu2AsvvNCdkevs/FjCyllnnWWnnnpqxnPVXqh25aqrrnKhSwcp2bNnj91zzz1WsmRJmzhxohUvXjzjMxdffLGbjrvuusvOOOMMu/fee4+YJw899JB98MEHVqBAgVzPd51MtGnTxqJFJy4KRK+88or16tXLhbTQMsSjNWvW2NChQ+2zzz6zokWLnujJiQk0A8UgVTl+88037qEq0q+//jpj5/XII4+4g4aqhq+99lqbO3dups/OmTPHvV63bl13oLjjjjsyalIefPBBe++99+z333/PaPoJbQbSX5016sDy97//3X2Pdsavvvpqpu/ZtGmT27npjEPfo+lSFbl29tnR51RVqwODpvHGG2+077//PtsmKU138Hg1fx544AG7++673UHs1ltvdU0Ceh6qXbt2bh54dNasg5HKdd5557lqeh2MspOWlubOkK+44gqrXbu2a9rQWbTXVOFNY6dOndxZqtdkou/W2erRvP/++/a3v/3N6tSp48b97LPP2oEDBzKaC1T2f//73+4MXcNo+XrrRHZV6fqcpis7v/32m5tvmheal5q3aioMXh5aXzSNwetibmheyLp16yzSFAaCa2uOl8KL1vv//ve/tnr1aveaanD0/8ceeyxTUPFccsklLlDozF7BLJjWdX1WtUu5oWWn5ap5pvmu9cDbfvr162fnn3++Wxc7dOjganeCaXjVGmk91zD6f1a0vqpMjRs3duvt1KlTwzarKdB07tzZ6tWr54a97777bOPGje49rRP6zrffftvtKzSM9kOiv9dff72de+651qhRI1cLpdqbUN999521b9/erStt27Y9omlNtVhDhgxx4VDbrobRtB5tnxlKNXH6juBmSdGyq1mzpmvqE33XqlWrXO2WQi2OH2ElBumsToFBD53paCPSgVHVz9oxKSRoB1S2bFnXh8ALLDob6NGjh9sYX375ZRs8eLD9+uuvro+KqvH1nnZyqvrWeHVgDEfD6uxKO2BVi2vno6aAL7/80r2vA6mmRTsYnTVqw166dKmrMs2OduQdO3Z0OxKdCasM+fPndztBHTRz46OPPrLChQu7cmoeXHnllfb555/brl27MoZRSNN0KTTIP//5T7vzzjutUqVKNmrUKOvZs6c749V8ya5jnoKYt6PU96kfwaRJk4743I8//uhCnQ7+Gr+aDHTGHbpjDKYQpAOalrHmh5bVG2+8kamvw9atW90w2umPGDHCnaF36dLFNa0cjxUrVrgDmkLJww8/7AKYDvxattrpe02EWl+03njrYm5pHZQKFSpkel0HxXAPrX+hgt/X+qcD5bhx49zB0Fu+kaLgJl5o09n1SSed5MJ1VtSPRU1J3kHaowO7wo+WqTe+nNC6ELytXnPNNbZlyxYXThYsWOD2AQow5cuXd+u01uPQg7LCtWq0FELC0bzU53TgV/OVAvPmzZtdeYOpCUwnFdoHaT+gPkha17UOBgcbTbPWU20vmlcKuNq21ayksKaQpRMTzQ8vFHj0mdatW9tLL71kVatWdeXTiYXs27fPrfvafrWtaxiFn/79+7tyZrXPDEfzRNP8ySefZHr9ww8/tGbNmmU0c2r/p3mjEzFEBs1AMahKlSrujDG4+lud4HTg1V+dXUuLFi3cGYUOMjpDWrRokduw1bauNm5RoFHAUe2B2uBVlR3c9BOuVkEHYB2ItYMU7Rj+9a9/2X/+8x9r3ry524h/+eUX953eWbN2yjqYZ8er1dFf72xFQUhnVPPnz3e1LTmlnat2ml7fBpVNO2/t4DQ+74y4WLFi7ixVZdJ80vTrr6dixYquRkRBJ1x40wFdZ3A6I/Q6JutgpgN5nz59XM2JDire2Z/Ohr2+DoUKFXI7ea+DaigdlBVqNN+Cw4kOetp5qs+H91xn9V65vHmtIKnarGOlg4vmn5o2vPVN80AHLx2UVG6tJxpG683Rmm00j4MPXgppCj0KeDp4eeuKJ6sDisKgDl5HG/aUU05xYTC4w3gkeP1YdOAWrbMKBdnxlrmGDaX1REFfwX769Ok5ag7SQTd0W1XfFQVX9Y/xpkfrntZfLS8tt8TEw+ev6iOjGsfsaN1VGRVYvc9oe1ANiWqLPAoEJUqUcCcjOrkQrf/aJtTPx6NAodo/b93WdqYAoJpCj7Z3nQQp1Gu+eLQcFX68/ZpOXhRKtJ5rm/r555/ddHmBUdux1jUNc91114XdZ4aj+aYAon2Dt39TzZf2ncHbkvrwILKoWYkTqj3RTlQ7be8MU80TqnbVWY4ODAox2pno7Eu1KtpBVq9e3Z2leBtyTgWfRXoHKy/Y6OCrs+Tgg4/Gr2nJjs4sVc0eXK2qToPa+Xo7jpxS7UhwJ0xNj3aEwdXHOuBr56nhFK50dYWCS/BZunZcmvbQM2KPDrbemXMwPVfNSXB1s+ZRcKdMBUXJ6ioO1TjoDLNVq1aZXtdOWztor7NmcnKyOxB5dLDTDl0B73iobFpmweuGvktl0zoV2qRxNJoerZ/eQ82Vai7QeqIDVmhzjcJQuEe4K46891RD0bJlSzfNqg1SrUJop9bj5dWW5aZ5yQsJ2iZDqQZQ26MOwMcTLrW8tF2GBifVKip0aB335KTpQicb6mejdXbnzp3uoe0luAnM2261vnlBRTQdqoEJ/p7g/2vd1jQFr7ei79Jnve3KE9ovRyFFNTpaBzWsyhxas6Vyq7ZHTdbhaFmEq7HT57SuemFU+wmtT0drwsbxoWYlTqi/ijaurM5G9Z7OLtQ8oTNu7dh1xqyaBZ3xqFozNzvf0LM/7Yy9nbiuxAh3VUh2V4p4ZTjaMDmlA0AoNQcMHDjQTZ+aNtTm/OSTT2Z8t6g2Ro9Q6gsQjteE451tBx/UU1NTXW2KJ/RqDW9+h2vWCJ6mo80TNUHo+4LpM97nj5XKpnGH+z4tazWphZvPWdG66c1blV0HNzUBZBWU1fcgp4KHVQ2AahPU6VV9DY7lSpvseJcue2FTB0qdeWdHTbBebU84qjVU84e2yayaZXKyvEKb0sRbhgobHtXqZUchWbWJqr0L19ShphSv03JOt9vg7/TWzazWLwWRcGXw6Pu8dVDlDt3+sip3MJ0EBNd0qZlLlyErkGk/oabkm2++2YUVLZPcdoBG7hBW4oR6pKuKNrgJI5h3VYPXoU7t+joj0k5H1biqYVGbcCSoiSlcH5PQduhwZQh3PwX1fVEnP29nEXp2erQOsB6VT80pagrSWaYOMmrCEoU2UdVzuMsQw3WcDH5dYTD4jFY7eYUiBZZj5U2TqvaDabzamXtnkuFCifoveAeQrELR0WpGVDaNJ5R3xpnbsinY5CaAHCsFZ/UhUg2QOhDrYBN81n+8VLOgeeqFIK+Ds/qKBAcjLSNtV5oe9YFQDY+a6LLiNQep78bRmkyzWl7esjne5aWmXNU2qBky9GoXNaeqZk9hULWSej90HRWFnaxqcNRsJFmtX6HTGhqc9TnVXKrMeujEI7flVvOj11E9eDiVR8tUYUXLS01Zur8OootmoBjlVSt7dIBVL3odoHRA8B5qvtBlh9qwdZapan1toNrJ6GxOZxDBV2KEjvdYaFoUOoI7eKqvjNcBNyva0esMNLidW9W4aq9WTZB3Bu5dZeCFgqOd1QYf/FV+9dFR05Kqe70DuZqNNO803cHzT8FLTRShZ3rBZRUdEIPpuUKVF4aOhaZJO1AdCIOpX4P6YXh9VkLnrZ6rv4HXx8ebb8E3M1Pn4qPVvOiMWt8d3ClZZVLZNG9C73XiJwqO6lel9UkdbSNF81D3IlLfHe9+I+qUqRMF1Rp589Tr8K5mDvXl0DJT/yQ1BWZFy0lhWkE/u3vMZLe81EE1tF+MgodqHk4//fQcj0thRH07FJp0lU7wQ1ebKZyon5q33Wo/E3zg1/aidVT30QlHzUuaJvUNCablpSuL1GQbTP3hPArds2bNcs3aOoFRuVVm76rB4HIrIOoELdy+zbvZn/cIvkxdtbCaDt37R7Vh3Ecl+qhZiVE68GrjVF8VdbZTJzg18ajTnO40qR2pzgC1o9ZO0jurU82L2vH1mgKMOqXpoOP1J9F4ddaS3VnR0WgHraYmfY/OvjRO3ZNCNStZVYOLyqA+B7qUWFfM6ECtanEdlNVUpTMo1SZoGO149Vzv6+B8tGptjwKKxq2DbvBVIpoX6rujjpv6v+aHqo/VQU/hKKvmNTWtqfpYV1Wo74l2nAppqr3Sjl0d/Y6Vd7XQE0884YKUzvbU1q/vUifT4NoenY2rKU/DqXOiapu8S7I1Hdqpq4pby8O7r4l3dpsVXQ2l0KOqcB14tA5pHdMBRQE42nSwyIoOdlnVdnnUFKSQq21Ay+honWBDaTl6Z/5atsuWLXOBX/MyuIOvmvc0P9VxXZ2c9b3eDfB0MqD7cWhdzskdYNU5W/2zFIhyS9u+DtD6fi07LV9dcaM+ZGruzOmJiMK/OqxmVZug5hPVkmnfodorhUI1Yan8Wle0PQ4fPtyFBJUnNESIpkX9lbTeqiOutkvVGGq70XIN7fyr8Wmb1X5NAULbgXefG+033nzzTbe/0bat0KH+Mupzo/ng1VCG7jOzW3+03Wr+KTSqj1QkL39HeISVGKWDlTo5du3a1VV56+xOl7mqFkBXBaivhHbO2hHo8kBRlbSafFS1qx2FNn51btSZn87ivQ1fQcXb8I/lhlPqP6EDpjoN6ioVPdfOSBu/d5lqVmeWOhjqygXt5HUGpbM7BRKvLV4HXL2nzpMaXp2FVXuR0527ro5QNa/GpwNeMB0ktBPWgVg7KQUgneEp4IXrC+BRORWetHPUgVFXQminrZ348dZUaTlrOjQ/NU3qJ6FlrkcwzWcdkHTGq2nWDt07k9ZOWlX3Wje0XLVeaCeuA1l2dImoDgLeZaXaYesApOUR6X4g4egAmBXvKqnsKITrChsdRBUYFChyQ/PIo6Cm+aYDtYJbaB8J7/4/mjdaF3Wmr6YnXTXi3RNF26iapUI7Y4fSMF999VXY+41kR9Ok5a7lrBoahXxt8wrc6nScU1qPFZS9K3dCKZypD4fKpBo6Hfh1AqHvVWDWdqntTPc6yq72TfsabW9jxoxx66U+p5CgfVPo/NU+Ttu+mns0T7WdebUdmh7v+3XpvmoCtT/Tdqn9Q3b7zKx4Hck1Xu27EH0JAX65CX8xNeOoT4gubww+I9GOQwfb7G5ChdxRCNH81Fk//EtNJAqHCrJZ3b8IiGfUrOAv591+XE03OhNVDY4uGdZZjc62gBMhJz9oqJqwSPTbCqUaBvX1ABAeYQV/OXV8Uxuzmi50NqnKPVUVq3klu6shgGhRx+mcNIWo6Uf9hAD8tWgGAhD31AyTk6YyNdN4d3cG8NchrAAAAF/jPisAAMDXCCsAAMDXCCsAAMDXYuJqIHW7SU+PTtebxMSEqI3bb+KprPFWXsoau+KpvJQ19sqY07v/xkRY0QLdujV3P0efE8nJiZaaWth27txjhw6F/+XbWBFPZY238lLW2BVP5aWssadkycKWlJSzsEIzEAAA8DXCCgAA8DXCCgAA8LWI9lnRr2zq11fD0c/Q6xdHRb8D8/LLL7tfyNQdIfXrqfzMNgAAiHpYadOmjfsJ72CzZs1yP7fdvXt39/zLL790P1anUKNfF/3pp5+sb9++7oe8brnllkhODgDkWenp6ZaWlv2PK6anJ9i+fUl24MB+S0uL7StHKGvek5SUHLEf/oxoWClQoIB7eDZs2GAjRoywHj16WNOmTd1rmzdvtm7dutlNN93knleoUMGmT59uc+bMIawAiHu6FcPOnVtt795dORp+y5ZEF2ziAWXNewoWLGLFipU87paTqF66PGzYMNfMo3DiueqqqzL+rwUxb948mz9/vt15553RnBQAyBO8oFKkSKqlpOQ/6k5el37m5bPv3KCseSt0q2Zo165t7nnx4qX8GVb0C6YzZsywUaNGuSaeUOvWrbNWrVrZoUOHrFmzZtaxY8fjvi490pKSEjP9jWXxVNZ4Ky9lzTvS09MygkqRIsWOOrxyjMqalpZusf6TtJQ171HYFgWW1NSSlpiY9Nf86vLatWutZcuWWb4/d+5cK1mypPu/+qQsXrzYNfGEOzPYtWuXrV692nWyHTRokDVo0MCGDx9+TIVQEeicCyCv27dvn61c+YuddFIZS0n5vyZ1IK86cGCfbdmy0SpXrpSpm0hUa1bKlCnjruTJSvHixTM2OHWs7d27d5YhokiRIlajRg33SEtLs/vvv98NX758+WO6g63u9BdpSrbFihW0nTv3uoQby+KprPFWXsqad6ja/HDHWsvRnUtj5Qw8Jyhr3qR1Wev0jh17bO/etEzvaVvNaS1orsJKvnz5rHLlykcdTp1lDx48aK1btz7ivQULFrhmodq1a2e8Vq1aNfd306ZNxxRWJJq3JNYKE8u3PI7XssZbeSmr/+W2j4J3IMvrB7ScoKx5m9bt49kmo9JnRYGkevXqlpqaesR7uteKQsnbb7+d8drChQstOTnZKlasGI3JAQAAeVhUeqEtWbLEhZVwOnXqZIsWLbLnn3/e9Vf56KOP3FVDN998c9hwAwBANPXs2c0GD37sRE8G/uqaFd1LpVatWmHfq1evno0ZM8Z1ph0/frzrkNu5c2fr2rVrNCYFAADkcVEJK9l1whXd5Tb0TrcAAAB/+U3hAAARusHWwfCdE9PSj6/jYk6k5EvM9e0hmjWrb7fe2tVmzvynHTp00F58cZyVLVvOxo172T755CPbvXuXnXFGZbvttu7WsGFjW7lyhd1yy3X26quTrFq1w90I+vV7wL77br7NnPmZJSUluatK2ra92O666z679NI29s9/vm9Tp75ta9asscTEBDvzzOp29933WfXqNdznO3S4wi64oKXNmzfHtm3baoMGPW01a9ay0aNfsE8+mWUHDx6wdu2udvM32JtvvmHvvz/VNm/eZCeddLJdfvmVdsstXbhFxglEWAEAH9OBdMik72zF7ztO2DRUObW49buhXq4P1u+9N8WeeWakHTqUZhUqnGaPPdbfVq361R55ZKCdfHJpmzPnC+vT51578slnrGnTZlau3Ck2f/48F1Z0S4vvv19ge/bssZ9/XmpnnVXTliz50f78809r0qSZff75v+3555+2vn0ftjp16tqWLVts+PBh9tRTg2z8+DczpmHatHdt6NDnrWjRolapUhU3zJw5X1r//o9amTLlbOLE12zhwu/tlFMOX4n61Vdf2BtvvG5PPPGkVahQ0RYvXmSDBj3qpk0BCScGYQUA/C6PntDr4O7Vcqxdu8Zmz/7YXn99slWtevh2Fdddd6OtWLHc3nxzogsr553X3ObP/9puvLGT/fTTYktOzmdnn13LvvtugQsrc+Z85YJJsWLF3H29HnxwgF1yyeFbZKjWpm3bK+25557ONA2NG59nDRo0cv/fs2e3ffTRDLv//r4u8Ei/fo+48XvWrVtrKSn5rGzZU6xs2bLucdJJpa1MmbJ/2XzDkQgrAOBjqs1QrUZWzUD6qRE/NgPJqaeelvH/n39e5v726HFbpmH0kytFihR1/1dY+eCD92z//n0utJx7bn0XGr79doHdcMMtLqxcdtnlbthzzqlnv/32q40f/4qtWvWbrV272jUlhf7436mnVsj4/+rVq9w9wKpXr5nxWv78+e3MMw+HJ7nkkjb24YcfWMeOV1nFipVc0FFTkkILThzCCgD4nIJC/pSkLMNKUqI/q14UBDyBwOEQMWrUOCtUqHCm4RITD99Fo27d+u7mo99//50tWPCNq5kpV66ca8rZsGG9LV++zAYPPlxzoj4ngwc/6mpWzj67trVrd5X98stKe+65oVlOg1dF5U2LR/f58pQoUcJef/1N+/HHRS4wff31XJsy5S3r0uV21wcHJ0be/LUvAECeos608scfW1xth/dQLYY64XqhoWHDJvbVV5+7/innntvAatc+x/VfefXVMVa5chXXd0QmTx5vV1zR3vr3f8yuvvpaV9Py++9r3XtZ/eTdaaed7n5cb9GihZlqdpYv/znjuTr/vvfeVPe9Cihjxx7+nk8//SSq8wfZI6wAAKKuUqXK1rRpcxs2bIjrxKpgMXnyBJs0abyVL39qxnDNmrVw4UVX4ej1/PkLuJqTjz+eaS1aXJAxXOnSZeyHHxbasmVL3bjeeWeyq4GRAwcOhJ2GQoUKWYcO19prr42xzz//zDUfPfPMENuyZXOm32caNWqEzZr1oa1fv84WLvyfq+nRNODEoRkIAPCXeOKJITZ27CgbNuxJ+/PPnXbKKae6TrKtW7fNGKZJk/NcTUq9evUzXqtfv6HrBNuixfkZr/Xq1ceefnqwu/usOsRWqXKmPfzw4/boow/Z0qVLXEfccG6/vaerXVFzka40uuiiVnbeeS0y3m/btr3t2LHD9YXZtGmju4pIfVbuuOPuqM0XHF1CIKv6sjz2o2Vbt+6O+HjVFpyaWti2bdudJ38ULTfiqazxVl7Kmnfovh9//LHeSpUqZ/nypeToM39FB1u/oKwWU+t0yZKFc/yryzQDAQAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAADign5hWT946NEvOXfocEXEvyda4z0R/FIWwgoAIC7861+z7IUXnj/Rk4FjQFgBAMSFGPjd3riVfKInAACQg4PsoQNZvJdogWj/Om9yiiUkJOTqI3PnzrFXXhltv/32ixUsWMiaNDnP7rrrPitWrJh9990C69XrTnviiads9OgXbOPGjXb22bWsf//H7K233rBZsz605OR8ds0119ktt3TJGOfMmTNs8uQ3bM2a1VayZElr27ad3XTTrZaUlOTe37hxg40ZM8oWLPjG9uzZbbVrn2M9etxjVapUtZkz/2lPPvm4G65Zs/o2cuTojPFOmjTe/vGPd23Hjh1Ws+bZ1qdPf6tQ4TT33q5du2zUqBH25Zf/toMHD1q1amdZjx53W/XqNTI+P336NHvzzYm2efNma9CgoZUrd0q286Znz25WocLptmLFz7ZmzSq7776+dsklre3DDz9w41m/fr2VK1fO2rW72jp0+Lv7zJVXXmo33niLXXfdje75u+++ZSNHPmuvvDIxY1r69+9tRYsWswcfHGALF37vmnCWLv3J/fLxKaeUt5tv7myXXtrGDTt48GO2d+9e2717ly1e/KPdcktnu+GGW45aluyWazQRVgDA50FlzweDLX3jihM2DUllqlrBKx/KcWDZvn27O3D27NnLmjZtZps2bbSBAx+1l14a4Q6kkpaWZhMnvmaPPjrI9SXp3fte69TpehdAxo6dYJ988pGNG/eyNWt2vlWuXMXeffdNGz36RTfOBg0a2ZIlP9pzzw11AeOee+534eSOO7q4g/JTTz1r+fKl2GuvjbWePbva+PFvWcuWrVzw0AF++vRZVqxYcfv++29tw4b19sMPC23YsBHuoD5w4CP21FMDbdSocW7e9+59t6WkFLChQ4dbkSJFXJDS94wZ87qdeWZ117Sk6bjnngesfv2G9sUX/7axY1+y0qXLZDuPZsx43wYMGGhVqlSxUqVOciFBQeu++/rYWWfVtJUrl9uzzz5lW7ZscoFLoWD+/G8ywsqCBV+75aHgp7Cieaj3H3lkoG3evMnuu6+nXX31313wUsiaPHmCK5fmXcmSpdw4/vOfT13w6tWrj+XPn/+oZcnJco0WwgoA+FyC5a5W40TbvHmjHThwwMqUKWtly5Zzj6FDn3MBJdhtt3XPqBU499wGLoDo4KmD8E03dbLx41+xX35ZYZUqVbZJkya4WoarrrrGDa+aDwUVHSi7dLndHWh37Nhur746yVJTU90wjz02yK69tr1Nm/auO+ArbIjCgSc5Odkd4AsXPvxeu3ZXuQO0fPvtfPvxxx/sww9nu3Ajt99+pws3U6a87WqCpk59xy6++JKM6brxxk62ePEPtnz5z9nOo6pVz7RLLrks4/mECa9ap05d7OKLL3XPTz/9NPvzzz/t2WeHWpcu3a1ZsxYuSGm+JiYm2vfff+eCnMLK9dffbP/733eWnp7makO2bNni5knHjjdlBEzVQCloHa6VOhxWVAujz3qOVpacLtdoIKwAgI/pYKNajayagZKTE+2Qz5qBqlat5g66ffv2csFAZ/NNmza3Fi0uyDTcqadWyPh/wYIFXZOD9z358xdwf1UrsH37Ntu69Q+rU+ecTJ+vW7eeq1FYteo3W7lyhWta8YKKN44aNVRLsTLLadWB2wsq3gF8//797v8//7zU1a5cfXXbTJ/RAdsbRmHKCxies8+ufdSwcuqph5uZZNu2ba6WYvToUa42yZOenm4HDuy39evXWYMGjd1zBSU1exUqVNAFqwEDHnTzYO7cr9wwKnP58qdamzZXukCl6Vu7do2tWLHcjTM4WATP/5yUJafLNRoIKwDgc+4Ani9/+PeSEy0hIcph5Rg89thg69y5q82b91+bP/9rGzhwgOtDMmLEy5lqNYJlFYiy6hibnh4IGk9Ww6RbcvLhPi3hqJYiK/ps4cKFXW1NqHz58nlTbYFA5vkfWq5w1Ozi8T5/9929rH79Ru7/SUkJlpZ2uExlypR131e3bn375pt57v/16jWwOnXq2qFDB23p0iX23/9+5WpP5Ndff7EePW6zatWqu0Bx/vkXWokSqda16y1ZTkNOy5KT5RoNXA0EAIgoddhU35DTTqto1157vesP0q/fI65ZZdu2rbken2o/9Fi48H+ZXlcnUh24VZNQuXJV11k1ePyq/VAH04oVK7nnue0kXKlSFdu9e7er3VEthPdQ/4+vvvo8ozln0aKFmT6n78yN1NSSLkysW/d7xneomWvZsp9s3LiXMsLaeec1t/nz57mmHzWbqTaqZs1arr+LPqtaDpk+/R+uA/Lw4S+5TrNNmjSzP/7446jTcbSyRHq55gZhBQAQUaqNmDZtir300kjXBKHmhU8//cQ1fRQvXuKYxqn+F+pT8d57U904P/lklutAe+WVf3N9UVq1usyNW80iP/202DV7PPHEw+6KFzWXiA7u3gF4//59R/3ORo2auAP4o4/2cwFB3/vCC8+5K4u8AKR+HeqIqito1B9k6tS3XcfV3FCIUqhQ+f7xj3fs99/X2n/+85k988xTrlknJSUlI6yoXOrbow6wotDy8cczXXNNiRKH5606xKpZSVfuqAPx559/5jrrek1YWTlaWaKxXHOKZiAAQERVrHiGDR48zF5/fZy9994U19SiZotnnx2ZbbNLdjp2vNEKFEixd95500aMeMYdkHWAv/76m9z7CiwvvDDGXnxxuN1zTw/3Wu3adezll191VwiJpqFGjbPtjjs6uytxjkZ9Q55//iXXifeRRx50wUchRWVTSBBdFaMrmhScdEmvajp0xY46/Oa2fGqWUUDQjevUJ0RBTB1lPWoO0pVRqu1R51ZRaNElyups6+nQ4TrXj0cdclUrVKFCBevWrYebRjUZNW7c1MI5WlmisVxzKiEQA3fJSUtLt61bd0d8vOq4lppa2LZt2x39DmwnWDyVNd7KS1nzDl06+8cf661UqXLu0tuc+Es62PoEZbWYWqdLlixsSUk5Czk0AwEAAF+LaFiZNm2aVatWLezj5pv/71ruYA8//LBddNFFkZwMAAAQQyLaZ6VNmzbWvPnh3sieWbNm2ZAhQ6x79+5HDD979mybMmWKlS9/uD0RAAAgqmGlQIEC7uHZsGGDjRgxwnr06GFNm2bu0LNp0yYbMGCANWzY0H7//fdITgYAAIghUe2zMmzYMCtdurR169Yt0+vq0/vggw9au3btXFgBAPyfGLjuAYjouhy1S5eXLVtmM2bMsFGjRmVcI+4ZP368+0XH0aNH25gxYyLWczrSvF7KOe2tnJfFU1njrbyUNe9ITDx8V1TdYj0lJfwda4N59zjT31jPN5Q1b9K6LPnz5zuuy5tzFVbWrl1rLVu2zPL9uXPnurvmeYFEHWtDh1+6dKm9+OKLNnny5CNCzLFKTExwlytGS7Fih28kFA/iqazxVl7Kmjfs31/Stm3b7m63fvh26NnfdfUv+A0536CseUnA3UF4z54dVqpUSStVqthxjS1XYaVMmTI2c+bMLN8vXvzwr1Lu27fPdazt3bt3ptsba8IfeOABu+OOO6x69eoWKfp9iJ0791ik6exMO72dO/e6e7nEsngqa7yVl7LmLQUKFLOCBQ/ajh05uX15gjtZO/wbOXn8FPyoKGteVLhwUbdO695HobSt5rQWNFdhRb/BULly5aMON2fOHHfXvNatW2d6feHChbZ8+XJXs6LmIdFw+sXIunXr2rhx46x+/fp2LKJ58xzt9GLh5jw5EU9ljbfyUta8o2jRkla4cAlLSzuU7XCqfSlevJDt2LEn40fvYhVlzXuSkpJd08/hMgT812dlwYIFruYk+Ke6pXbt2vbJJ59keu2NN95wr+mvam4AAId/DTgxMeWoffV0BebevWl5OpzlBGWNb1EJK0uWLAnbzKOZf/rppx/RdKSfoA59HQAAQKLSZV5X+ni//ggAAOC7mpXsOuGGuuuuu9wDAAAgnLx5MwIAABA3CCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXCCsAAMDXkiM5smnTplm/fv3CvteoUSObOHGi+//DDz9sU6ZMyfR++fLl7bPPPovk5AAAgBgQ0bDSpk0ba968eabXZs2aZUOGDLHu3btnvLZs2TL3/MYbb8x4LSkpKZKTAgAAYkREw0qBAgXcw7NhwwYbMWKE9ejRw5o2bepeCwQCtmLFCuvWrZudfPLJkfx6AAAQg6LaZ2XYsGFWunRpF0w8q1evtj179lilSpWi+dUAACBGRLRmJZiaembMmGGjRo2ylJSUjNd//vln9/eNN96wL774whITE61FixbWq1cvK1q06DF/X3Jy5HNXUlJipr+xLJ7KGm/lpayxK57KS1njW67Cytq1a61ly5ZZvj937lwrWbKk+//48eOtWrVqRwyvsKKAohqX0aNHu5qWp59+2pYvX24TJkxw7+VWYmKCpaYWtmgpVqygxYt4Kmu8lZeyxq54Ki9ljU8JAXUiyaGDBw+6cJGVihUruo6y+/btsyZNmljv3r3t+uuvzzRMenq67dixw1JTUzNeW7hwoV177bX27rvvWp06dXJdiLS0dNu5c69FmlKtVhaNW98Ry+KprPFWXsoau+KpvJQ19qiMOa09ylXNSr58+axy5cpHHW7OnDku2LRu3fqI91RzEhxUpGrVqhkdco8lrMihQ9FboFpZojl+P4mnssZbeSlr7Iqn8lLW+BSVBrEFCxZY9erVjwgl0qdPH+vUqVOm13744Qf3t0qVKtGYHAAAkIdFJawsWbLEhZVwLr30Ute35cUXX3RNSp9//rk99NBD1rZt2xzV2gAAgPgSlauBNm/ebLVq1Qr7njrcDh8+3MaOHWvjxo1zVwBdccUVdu+990ZjUgAAQB4XlbAyc+bMbN9XX5Zw/VkAAABCcRE3AADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwNcIKAADwteRIjmzatGnWr1+/sO81atTIJk6c6P6/adMme+qpp+yLL76wpKQka9asmfXv399KliwZyckBAAAxIKJhpU2bNta8efNMr82aNcuGDBli3bt3d88PHDhgnTt3tiJFirjwcvDgQXvooYesb9++Nm7cuEhODgAAiAERDSsFChRwD8+GDRtsxIgR1qNHD2vatKl7bcaMGfb777/bv/71LzvppJPcaw8++KA9/vjjtmvXLhdiAAAAohJWQg0bNsxKly5t3bp1y3jtq6++ssaNG2cEFVFtzOzZs6M5KQAAII+KWlhZtmyZq0UZNWqUpaSkZLz+66+/Wv369d3r77//vh06dMj1Wendu7cVK1bsmL8vOTnyfYWTkhIz/Y1l8VTWeCsvZY1d8VReyhrfEgKBQCCnA69du9ZatmyZ5ftz587N6CSrjraLFy+26dOnW0JCQsYwrVq1su3bt1uTJk3stttusx07drg+LfrcG2+8kWnYnFIRjuVzAAAgxmpWypQpYzNnzszy/eLFi7u/+/btcx1rVVsSGiKSk5OtUKFC9uyzz1q+fPkyPnfNNdfYDz/8YLVr1851IdLTA7Zz5x6LNKXaYsUK2s6dey0tLd1iWTyVNd7KS1ljVzyVl7LGHpUxp7VHuQorCheVK1c+6nBz5sxxV/m0bt36iPfKli3rakK8oCJVq1bNqLk5lrAihw5Fb4FqZYnm+P0knsoab+WlrLErnspLWeNTVBrEFixYYNWrV7fU1NQj3mvQoIEtXbrU1b54fv75Z/f39NNPj8bkAACAPCwqYWXJkiUurIRz3XXXuRvB3X///bZ8+XL79ttv7eGHH3Y3jatZs2Y0JgcAAORhUQkrmzdvthIlSoR9Tx1pJ0+e7K4CUj+VO+64w2rVqmUvvvhiNCYFAADkcVG5dDm7TrhSsWJFGzNmTDS+GgAAxBgu4gYAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL5GWAEAAL6WHMmRTZs2zfr16xf2vUaNGtnEiRPtpptusm+++SbsMEOHDrX27dtHcpIAAEAeF9Gw0qZNG2vevHmm12bNmmVDhgyx7t27u+cvvPCCHTx4MOP9QCBgvXr1sh07dlirVq0iOTkAACAGRDSsFChQwD08GzZssBEjRliPHj2sadOm7rUSJUpk+sykSZNs0aJFNn36dCtcuLD5SXp6uu35c5ft273XDh1Kt1iWnJxoe5IDcVHWeCsvZY1d8VReynpipRQsYImJibERVkINGzbMSpcubd26dQv7/tatW2348OF2xx13WKVKlY574UY6qCwd28/Kpa+3eKC6rr0WP+KpvJQ1dsVTeSnribUqsZyd1W3ICQssUQsry5YtsxkzZtioUaMsJSUl7DDjxo1zNTFdunQ5ru9KTEyw1NTCEQ8rlpAQ0XECAJAXJSQcPs7mibCydu1aa9myZZbvz50710qWLOn+P378eKtWrVqWw+/atcveffdd69mzp+XPn9+OR3p6wHbu3GORVrP7U5aSFLA/d+2z9LSAxbLEpAQrWqRAXJQ13spLWWNXPJWXsp5Y1QsWsB07IlvfU6xYQUtKSox8WClTpozNnDkzy/eLFy/u/u7bt891rO3du7dLY+HMnj3bDhw4YFdffbVFQjTa9dS0VKhoEdt/KME37YbRcrisheOirPFWXsoau+KpvJT1xFJjg2txOEFyFVby5ctnlStXPupwc+bMcVf8tG7dOsthFFbOP/98K1asWG4mAQAAxJmoND4tWLDAqlevbqmpqdkO06RJk2h8PQAAiCFRCStLlixxYSUr69evt23btmU7DAAAQNTCyubNm4+4n0ro+5LdMAAAAFG7dDm7TrhSu3Ztd2kzAADA0fBDhgAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNcIKwAAwNeSIzmyadOmWb9+/cK+16hRI5s4caL7/+LFi+2pp56yH3/80YoXL25t27a1u+++21JSUiI5OQAAIAZENKy0adPGmjdvnum1WbNm2ZAhQ6x79+7u+bZt26xz58522WWX2aBBg2z16tXWt29fS09Ptz59+kRycgAAQAyIaDNQgQIF7OSTT854pKWl2YgRI6xHjx7WtGlTN8y3335r27dvt969e9vpp5/uws0VV1xhX375ZSQnBQAAxIio9lkZNmyYlS5d2rp165bxWsmSJd3ft956y4WZtWvX2ueff2516tSJ5qQAAIA8KqLNQMGWLVtmM2bMsFGjRmXqi1KvXj274447XI3L888/7wJL48aN7ZFHHjmu70tOjnzuSkpKzPQ3lsVTWeOtvJQ1dsVTeSlrfEsIBAKBnA6sWpCWLVtm+f7cuXMzak7U0VYdaadPn24JCQkZw+zatcseeughK1eunF155ZW2Zs0a16dFgWXo0KHHVAgVIfg7AABAnNaslClTxmbOnJnl+7qyR/bt2+c61qpfSmiIUNPQjh07bOTIke55zZo13ec6derkHmeddVauC5GeHrCdO/dYpCnVFitW0Hbu3GtpaekWy+KprPFWXsoau+KpvJQ19qiMOa09ylVYyZcvn1WuXPmow82ZM8cOHjxorVu3PuI9dbC94IILMr3m9Vf57bffjimsyKFD0VugWlmiOX4/iaeyxlt5KWvsiqfyUtb4FJUGsQULFlj16tUtNTU1bO2M+rME856fccYZ0ZgcAACQh0UlrCxZssSFlXDU1KPLlIcPH+7usaJ+LurfotqWrD4DAADiV1SuBtq8ebPVqlUr7Hu6r8qYMWPcVUITJkxwtS+tWrWye+65JxqTAgAA8riohJXsOuHK+eef7x4AAABHw0XcAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAADA1wgrAAAgfsLKtGnTrFq1amEfN998c8ZwX375pV199dVWt25du+KKK2zGjBmRnAwAABBDkiM5sjZt2ljz5s0zvTZr1iwbMmSIde/e3T3/9ttvrWvXrnbDDTfY008/bUuXLrUBAwbYoUOHrH379pGcHAAAEAMiGlYKFCjgHp4NGzbYiBEjrEePHta0aVP32quvvmq1a9d2AUUqV65sq1evtpEjRxJWAADAX9tnZdiwYVa6dGnr1q1bxmurVq2yc889N9NwNWrUsN9//93WrVsXzckBAADxXrMSbNmyZa4vyqhRoywlJSXjdYWX9evXZxp27dq17u8ff/xhp5xyyjF9X3Jy5HNXUlJipr+xLJ7KGm/lpayxK57KS1njW67CikJFy5Yts3x/7ty5VrJkSff/8ePHu461ocO3a9fOHnroIfvggw9cH5fly5fba6+95t47ePDgMRUiMTHBUlMLW7QUK1bQ4kU8lTXeyktZY1c8lZeyxqeEQCAQyOnAChPqX5KVihUrWlJSku3bt8+aNGlivXv3tuuvv/6I4VTbMnbsWDtw4ICVK1fOdbh97LHHXE1M1apVc12ItLR027lzr0WaUq1WFo1b3xHL4qms8VZeyhq74qm8lDX2qIw5rT3KVc1Kvnz5XIfYo5kzZ44LNq1btw77/p133umuDtqyZYudfPLJ7lJmhZxjbQKSQ4eit0C1skRz/H4ST2WNt/JS1tgVT+WlrPEpKg1iCxYssOrVq1tqauoR702aNMkGDhzowkmZMmUsMTHRPv74Y3fPlcKFo9eUAwAA8qaodLBdsmSJCyvhqGZG912pVauW1a9f32bOnOn6r3j9VgAAAKIeVjZv3uzCSDjqy/L444/bSy+9ZBs3brQqVarYyy+/bA0bNozGpAAAgDwuKmFFtSXZ6dChg3sAAAAcDRdxAwAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAACA+Aoru3fvtscff9yaNWtm9evXt65du9rKlSszDTN37ly76qqrrE6dOnbZZZfZhx9+GOnJAAAAMSLiYWXgwIH29ddf28iRI+2dd96xpKQku+2222z//v3ufQWX22+/3Zo3b27Tpk2za665xvr06eMCDAAAQNTDyuzZs61jx45Wr149q1y5st177722bt06W7FihXt/woQJVq1aNevVq5d7v0uXLq525ZVXXon0pAAAgBiQHOkRlipVymbOnGlt2rSxokWL2tSpU61EiRJ22mmnufcXLFhgF198cabPNG7c2AYPHmyBQMASEhKO6XuTkyPf/SYpKTHT31gWT2WNt/JS1tgVT+WlrPEt4mFFoUPNOk2bNnVNQIUKFbLXXnvNBRfZsGGDlS1bNtNnSpcubXv37rVt27ZZyZIlc/2diYkJlppa2KKlWLGCFi/iqazxVl7KGrviqbyUNT7lKqysXbvWWrZsmeX76neybNkyq1Chgg0aNMgFlXHjxlnPnj1d/5Vy5crZvn37LCUlJdPnvOcHDhw4pkKkpwds5849FmlKtVpZdu7ca2lp6RbL4qms8VZeyhq74qm8lDX2qIw5rT3KVVgpU6aMa+LJyq+//uo62H722Wd2yimnuNeGDx9urVu3drUr/fv3t/z58x8RSrznBQsee4o8dCh6C1QrSzTH7yfxVNZ4Ky9ljV3xVF7KGp9yFVby5cvnOsVm5dVXX3V9Vryg4n2mRo0atmrVKvdctSubNm3K9Dk9Vy2M11QEAADgiWjvHfVFUb+T4DCSnp7urgSqWLGie657r3zzzTeZPjdv3jx39VBiIp2JAABAZhFNBxdeeKHrr3L33XfbwoUL3T1VBgwYYOvXr7ebb77ZDXPTTTfZokWL7JlnnnHvq3lo1qxZ7l4sAAAAUQ0rasqZOHGilS9f3u6880677rrrXFB566237NRTT3XDVK1a1V566SX7/PPPrX379jZlyhQbNmyYNWnSJJKTAgAAYkTEL11WJ9xnn30222FatGjhHgAAAEdDJxEAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAAOBrhBUAABBfYWX37t32+OOPW7Nmzax+/frWtWtXW7lyZdhhV61aZeecc46tXbs20pMBAABiRMTDysCBA+3rr7+2kSNH2jvvvGNJSUl222232f79+zMNpwDTuXNn27t3b6QnAQAAxJCIh5XZs2dbx44drV69ela5cmW79957bd26dbZixYqMYcaMGWMdOnSw4sWLR/rrAQBAjIl4WClVqpTNnDnT/vjjDztw4IBNnTrVSpQoYaeddlqmQDNkyBDr27dvpL8eAADEmORIj3Dw4MHWp08fa9q0qWsCKlSokL322mtWtGjRjGGmTJni/qq5KFKSkyPfVzgpKTHT31gWT2WNt/JS1tgVT+WlrPEtV2FFHWFbtmyZ5ftz5861ZcuWWYUKFWzQoEEuqIwbN8569uzp+q+UK1fOoiExMcFSUwtbtBQrVtDiRTyVNd7KS1ljVzyVl7LGp4RAIBDI6cAHDx601atXZ/n+9u3b7YYbbrDPPvvMTjnllIzPtG7d2i688ELr379/puFVs3LzzTfbp59+aqeeeuoxFyItLd127ox8R12lWq0sGre+I5bFU1njrbyUNXbFU3kpa+xRGXNae5SrmpV8+fK5TrNZefXVV12fFS+oeJ+pUaOGu0w5mg4dit4C1coSzfH7STyVNd7KS1ljVzyVl7LGp4g2iJUtW9a2bdtmmzZtyngtPT3dXQlUsWLFSH4VAACIExENK2rqUX+Vu+++2xYuXOjupTJgwABbv369a+4BAAA4oWFFHWonTpxo5cuXtzvvvNOuu+46F1Teeuut4+qTAgAA4lfEL10uU6aMPfvsszkatlGjRu7qIQAAgKxwETcAAPA1wgoAAIid+6z4lYqQnh6dYuga8Fi+zj1YPJU13spLWWNXPJWXssYW3dA1ISEhfsIKAACIXTQDAQAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAXyOsAAAAX4vrsJKenm4jR4605s2b2znnnGNdu3a1NWvWZDn8tm3b7P7777cGDRpYw4YN7fHHH7e9e/daXrB9+3Z75JFHrEWLFlavXj3r2LGjLViwIMvhX375ZatWrdoRj7xi48aNYad/2rRpMbVsv/7667Dl1KNly5ZhP/Ptt9+GHV7j8rMxY8bYTTfdlOm1n376yW688Ua3/V500UU2ceLEo47no48+sjZt2ljt2rWtffv2NnfuXMsLZf3ss8/s6quvtrp167qyDh061Pbt25flONLS0lwZQ5fzCy+8YHmhvA8//PAR065yx9qy1f+z2obff//9LMdz6623HjF86DyMKYE49sILLwQaNWoU+Pe//x346aefAp07dw5ccsklgf3794cd/sYbbwxcffXVgR9//DHw3//+N3DhhRcG+vTpE8gLbr311kDbtm0D8+fPD/zyyy+Bxx9/PFC7du3AypUrww5/zz33BHr37h3YtGlTpkde8Z///CdQq1atwMaNGzNN/969e2Nq2WpdDV1Gn3zySaBatWqBqVOnhv3M5MmTAxdffPERn8tqvfeDSZMmBapXr+6Wk2fr1q1u++3Xr19gxYoVrrxa5lmVW+bOnRuoWbNmYMKECe4zTz31VODss892//dzWbXdnnXWWYGXX3458Ouvv7r1u0WLFoEHH3wwy/GoTGeeeabbtwUv5127dgX8JFx5pUOHDoHnnnsu07T/8ccfMbdst23blqmM2mddf/31gcsvvzzbZdWkSZPAm2++memzGlesituwoh1z3bp13Y7bs2PHDncA/+c//3nE8N99953b8INX/C+//NIdFDZs2BDws99++81N+4IFCzJeS09Pdwes4cOHh/1M69atA6+//nogrxo7dmzgiiuuyNGweXnZhtq9e7cLWtkdxB599NFA9+7dA3mB5v/tt98eOOeccwKXXXZZpp386NGjA82aNQscPHgw47Vnn33WnXBkRSckCuLB/v73vwcGDBgQ8HNZ77///kCnTp0yDf/ee++5g3NWIfPDDz8M1KtXL+BX2ZVX+ye9ruCdU3l12YZ64403XMjK6kRStmzZ4vZZixcvDsSLuG0GWrp0qe3evduaNGmS8VqxYsWsRo0aNn/+/COGV5PJySefbJUrV854Tc0FCQkJrlrdz1JTU23s2LFWq1atjNc03Xrs3LnziOEPHDhgv/32m1WqVMnyqmXLlmVaVtnJy8s21OjRo13zVd++fSMyb060xYsXW758+eyDDz6wOnXqHLHctJySk5MzXmvcuLFbd7ds2RK22fe7777LtM1Lo0aNwm7zfipr586dj1imiYmJdvDgQdu1a1eeXM7ZlXf16tW2Z8+eHO+D8vKyDbZ161YbPny43XHHHdmWfdmyZW7/dMYZZ1i8+L+tPM5s2LDB/S1Xrlym10uXLp3xXmgfiNBhU1JSrESJErZ+/XrzM4Ww888/P9NrH3/8sa1atcoeeuihI4ZfsWKFa+/WMIMHD7b9+/e7vhy9e/d28ycv+Pnnn11Iu+GGG+zXX3+1008/3e0A1GcnlpZt6I5u/Pjxru+Npj0ry5cvd/PmqquucmU/88wzrVevXq6d32/URyGrfgraTjXtwbz1U8vtpJNOyvSegrkOgGXLls3RNu+nsuokKphCipb12WefbSVLlsxyGzh06JB16dLFnZyVKVPGbrnlFmvXrp35QXbl1bTLG2+8YV988YULZtp2tZ4WLVr0iOHz8rINNm7cOCtQoIBbZtn5+eef3Xx44oknbM6cOVaoUCG77LLLrEePHm7fFYvitmbF6zwZumDz58/vDs7hhg+3EmQ1vJ/pDKRfv352ySWX2AUXXJDljqJgwYI2YsQIF1h++eUXu/nmm7Pt0OcX2kFrenfs2GF33XWXq1VSB8xu3bqF7XAXK8v2zTffdDuwv//971kOo4P4n3/+6Xbs6sD40ksvuYO6OqkqpOYlWhfDbb8Sbrl5625Ot3k/r999+vRxofPRRx/Ncji9r4716nT56quv2qWXXuq2+6lTp5rfaR+kgKKwodrCBx980L766it3MFYtSiwuW9WQvfvuuy6oeOtxdvNn//797gTjlVdecSdiU6ZMcdt0rIrbmhWlV6/Jw/u/aAXQQTrc8Bo2lIZXqs0rZs+ebQ888IC7IuiZZ54JO4x60essJviMrWrVqu41XZGg3vZ+pmYBXdmSlJSUsWx1Bqqdt3baoVXFsbJsdeWAll3w+hxKNUiqFtc6rmppUfPgkiVL3FmsroLKK8ItN+/AFG65eQeAcJ8Jt8379YB277332jfffGMvvvhitrVhM2bMcDWkhQsXds+rV69u69atc9tAhw4dzM908L3++utdDaCoBk1Ntddee6398MMPRzSlxMKy1b5Z068rvo7miSeecM2CxYsXz5g/2p5V86QgG1qrGAvitmbFq/bftGlTptf1XNWloVS9GDqsViydueSVppFJkya5moYLL7zQna1kl95Dq5ZVRjUt+KFKNSe0gw49aCtwqdkjFpetqvl12f0VV1yRo2ZBL6iIzmDVtyHcvPGzcMvNex5uG9b6qxCT023ebzSdatb83//+5wJHaNNuKK3/XlDx6KCWF7ZhrZNeUAnefiXc9Of1ZeuFFS1TbZ85OSEr/v+DSk7mTyyI27Cis4wiRYpkureE2j11hqn+GaH0mlYC9fPw6OxGzj33XMsLTQQDBw50O7vnnnsu23bN559/3lUZ62oxz9q1a929SKpUqWJ+pxoU1RyF3jfkxx9/DDv9eX3Zep1NS5Uq5dbr7Kj9X/fpCL6fkJoVFHbywrINXW7qAK3aA8+8efNcp0PNi1DqkKj1wlu2Hq0n9evXNz9Tk6b6m6hf0uTJk8Puo4JpX6bOx6H3FVKthHdQ8zPVDnTq1OmIaZdw62leXrbB23BorW9WbrrpJtekFzp/dBJSsWJFi0VxG1Z0sFY7vZpCPv30U7ezVhWaztbUl0M7wM2bN2e0haraURuDhlm0aJHbKeoma6p293tyVwfTJ5980lq1amW33367u1JCZdND/RdUi6D/e1WoGu7333+3xx57zH1WzQaqkVH5dQM9v1MtgXrSq6pUO4CVK1fakCFD3Bmpqpdjadl6FLKzummfyqor30Tl1BmrqpAV3nRVgf6vWqTQg4PfqbpczSL9+/d3/W10YFanU63jHq3fOsAH30jrww8/tNdff92tF08//bS7sZyCgJ9p/VXAHDZsmKv19LZfPbywpmWoh+jsXFdG6cTj888/d1dIqe+WrkbRtux3OllS/zI1denKIJVBFwO0bds24wqnWFm2Xl8ynQxmdbKxe/dut6yD58/06dPtrbfecuvFzJkzXXnV30Un4TEpEMcOHToUePrppwONGzd217937do1sGbNGvee/uo69n/84x+Zrm2/66673LC6GZXuV7Fv376A3+lGUipLuEffvn0D8+bNc//XX49ujKZ7FKisDRs2dDfe2r59eyCv2Lx5s7vXyHnnneduFKay6MZasbZsPbfddlvg3nvvDfueyjpy5MiM56tWrXJl1XKtU6eOuz/FsmXLAn6ndTX0/hQLFy4MXHvtte6+FLq/jO5REfoZvR56f5JWrVq59eJvf/ubW9f9XFbtpzStWW3D3j5LwwfPnz///DPw5JNPBs4//3w3f9q1axf417/+Fcgry3bmzJmB9u3bu3tfaTvWTd6Ct8lYWLbB63HovZ6CjRw50r0feoM53Q/LW/e1n09LSwvEqgT9c6IDEwAAQFbithkIAADkDYQVAADga4QVAADga4QVAADga4QVAADga4QVAADga4QVAADga4QVAADga4QVAMdFv6uk35zSrzfrt0327t17oicJQIxJPtETACBvmzBhgvvdJf1ujX5LqWDBgid6kgDEGMIKgOOiH88rXbq0tWnT5kRPCoAYRTMQgGN20UUXuV87XrdunfvVZ/10vf6+/fbbduGFF7pfeZ4zZ44bdsqUKXbVVVfZOeecY7Vr17Z27drZRx99lDEujUdNSfqlbP2isv6vX5f97LPP7JdffnG/nqtfyNavguvXdYPp+++77z5r2LChG0bD6peog82YMcOuvPJK9936ReIHHnjANm7c+BfNKQDHgx8yBHDMFAiGDx/u/r744ou2atUq69Onj5188sn28MMP2759++ySSy6x9957zwYNGmR33XWXnXvuubZjxw4bN26c+9ynn35qZcuWdWGlf//+rpamZ8+eVq5cOXvmmWds9erVdtJJJ1nHjh2tevXq7nsWLlxos2fPdp/bunWrtW/f3jU/6XP6q6apH3/80aZOnWqVK1e2b7/91gWpHj16WIMGDVw/GzVbVaxY0SZNmnSiZyOAo6AZCMAxq1GjhpUsWdJSUlJcjcn+/fvd69dff71ddtllGcOtWbPGunTp4sKCp3z58q6mRUHi8ssvd6+lp6db9+7d7ZprrnHPd+7cab169XI1Jbfeeqt7rWjRoq7mRWFEYUXBRE1Rb731lhuntGjRwjVLjRgxwkaOHOm+o0CBAtatWzc3rVKiRAn74YcfTOdrCQkJf+FcA5BbhBUAEXfWWWdlev7ggw9mhA816agG5uuvv3avHThwINOwdevWzfh/qVKl3F817XgUMrxxydy5c933qXPvoUOH3GuJiYkusHzwwQfuuWpTnn/+eWvbtq1rWjr//POtWbNm7i8A/yOsAIi4QoUKZXquppxHHnnEBYt8+fJZpUqVXJOOhLZEFylS5IjxZXeFkWpVFH5q1qwZ9n1dSq0ANHbsWBs/fry9/vrr7v9qWlItjpqHAPgbYQVAVKlpR80vCinqQ6JakOTkZFuxYoVNnz79uMevZiF1rFVfmXC8Zp/mzZu7h8LLvHnzbOLEia4fjWpt1OkWgH9xNRCAqNq2bZv9+uuv1qFDB3eFj4KKfPHFFxlh5ngoqGj8Z5xxhhu/91AQUjhKSkqyoUOHun4uqsVRLY2uVOrbt2/GlUQA/I2aFQBRpX4n6vg6efJk1yG2WLFi9uWXX7qaDTneO9526tTJBRP97dy5s6WmptrMmTPt3XfftX79+rlhdKmymn/Ud0aXLx88eNBeeeUV1/9F7wHwN2pWAETdSy+95DrAKizce++97tLjl19+2fVd0X1VjofGq/u6KBA99thjrh/KokWLbPDgwS7AiDrS6jLo5cuXu8ubdU8W1bAoMHkddgH4F/dZAQAAvkbNCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAA8DXCCgAAMD/7f2o/Le6qW1NvAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def test(cfg, env, policy: Policy):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    frames = []\n",
    "    for i_ep in range(cfg.max_epsiode_test):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        frames.append(i_ep)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.max_epsiode_test}，奖励：{ep_reward:.2f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'frames':frames}\n",
    "cfg.mode = 'test' # 测试模式\n",
    "test_env = make_env(cfg)\n",
    "test_policy = Policy(cfg)\n",
    "test_policy.load_policy_params(res['best_policy_params']) # 加载训练时的最佳策略参数\n",
    "test_res = test(cfg, test_env, test_policy)\n",
    "plot_rewards(cfg, test_res['frames'], test_res['rewards'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
